/**
 * 确定性配置系统
 * 
 * @description
 * 统一配置，支持三种模式：
 * 1. FLOAT - 标准浮点数（最快，不确定）
 * 2. PRECISION - 精确度保留（推荐，快速且基本确定）
 * 3. FIXED - 定点数（最慢，100% 确定）
 */

/**
 * 确定性模式
 */
export enum DeterministicMode {
    /** 标准浮点数模式（默认） */
    FLOAT = 'float',
    
    /** 精确度保留模式（推荐） */
    PRECISION = 'precision',
    
    /** 定点数模式（严格确定性） */
    FIXED = 'fixed'
}

/**
 * 确定性配置
 */
export class DeterministicConfig {
    
    /** 当前模式 */
    private static _mode: DeterministicMode = DeterministicMode.FLOAT;
    
    /** 精确度位数（用于 PRECISION 模式） */
    private static _precisionDigits: number = 6;
    
    /** 是否启用日志 */
    private static _enableLog: boolean = false;
    
    /** 模式切换回调 */
    private static _callbacks: Array<(mode: DeterministicMode) => void> = [];
    
    /**
     * 获取当前模式
     */
    static get mode(): DeterministicMode {
        return this._mode;
    }
    
    /**
     * 获取精确度位数
     */
    static get precisionDigits(): number {
        return this._precisionDigits;
    }
    
    /**
     * 设置模式
     */
    static setMode(mode: DeterministicMode): void {
        if (this._mode === mode) return;
        
        const oldMode = this._mode;
        this._mode = mode;
        
        if (this._enableLog) {
            console.log(`[Deterministic] 模式切换: ${oldMode} -> ${mode}`);
        }
        
        // 触发回调
        for (const callback of this._callbacks) {
            callback(mode);
        }
    }
    
    /**
     * 设置精确度位数
     */
    static setPrecision(digits: number): void {
        if (digits < 0 || digits > 15) {
            throw new Error("精度必须在 0-15 之间");
        }
        this._precisionDigits = digits;
        
        if (this._enableLog) {
            console.log(`[Deterministic] 精确度设置为 ${digits} 位小数`);
        }
    }
    
    /**
     * 是否为确定性模式
     */
    static isDeterministic(): boolean {
        return this._mode !== DeterministicMode.FLOAT;
    }
    
    /**
     * 是否为浮点数模式
     */
    static isFloat(): boolean {
        return this._mode === DeterministicMode.FLOAT;
    }
    
    /**
     * 是否为精确度保留模式
     */
    static isPrecision(): boolean {
        return this._mode === DeterministicMode.PRECISION;
    }
    
    /**
     * 是否为定点数模式
     */
    static isFixed(): boolean {
        return this._mode === DeterministicMode.FIXED;
    }
    
    /**
     * 快速配置：浮点数模式
     */
    static useFloat(): void {
        this.setMode(DeterministicMode.FLOAT);
    }
    
    /**
     * 快速配置：精确度保留模式（推荐）
     */
    static usePrecision(digits: number = 6): void {
        this.setPrecision(digits);
        this.setMode(DeterministicMode.PRECISION);
    }
    
    /**
     * 快速配置：定点数模式
     */
    static useFixed(): void {
        this.setMode(DeterministicMode.FIXED);
    }
    
    /**
     * 启用/禁用日志
     */
    static setEnableLog(enable: boolean): void {
        this._enableLog = enable;
    }
    
    /**
     * 添加模式切换回调
     */
    static onModeChange(callback: (mode: DeterministicMode) => void): void {
        this._callbacks.push(callback);
    }
    
    /**
     * 移除模式切换回调
     */
    static offModeChange(callback: (mode: DeterministicMode) => void): void {
        const index = this._callbacks.indexOf(callback);
        if (index >= 0) {
            this._callbacks.splice(index, 1);
        }
    }
    
    /**
     * 获取配置摘要
     */
    static getSummary() {
        return {
            mode: this._mode,
            precisionDigits: this._precisionDigits,
            isDeterministic: this.isDeterministic(),
            enableLog: this._enableLog,
            performance: this.getPerformanceEstimate(),
            determinism: this.getDeterminismLevel()
        };
    }
    
    /**
     * 获取性能预估
     */
    private static getPerformanceEstimate(): string {
        switch (this._mode) {
            case DeterministicMode.FLOAT:
                return '100% (最快)';
            case DeterministicMode.PRECISION:
                return '80-90% (推荐)';
            case DeterministicMode.FIXED:
                return '20-30% (较慢)';
        }
    }
    
    /**
     * 获取确定性级别
     */
    private static getDeterminismLevel(): string {
        switch (this._mode) {
            case DeterministicMode.FLOAT:
                return '0% (不确定)';
            case DeterministicMode.PRECISION:
                return '99%+ (基本确定)';
            case DeterministicMode.FIXED:
                return '100% (完全确定)';
        }
    }
}

/**
 * 全局快捷访问
 */
export const DetMode = DeterministicConfig;

